Go逆向_1

2022-02-17

字数统计: 4k字 | 阅读时长≈ 20分

VNCTF2022可把我打惨了。摆烂的结果就是这样的。开始好好学了（不我还是去打《底特律》吧）

更新：摸鱼摸到3号才写完，我无语了。

Go逆向_1

简要

Go的逆向还是要比Cython逆向好多了。Cython的内联简直要人命。

学习要点一切以加速逆向速度为核心。

谈谈我打算学习的知识。

Go语言基础（不写博客）
一些小技巧
Go语言底层内存模型
Go程序结构

环境

1	go version go1.16.4 windows/amd64

现在最高版本应该是1.17.7，但是各个版本之间的区别以后再说。

Go程序的初始化

入口函数是很重要的一环。

`rt0_amd64_windows`

保留符号表的Go程序，用IDA反编译后并不能在函数栏里面很快的发现入口点。但是通过扔进DIE或者其他识别工具，我们知道第一个入口函数是rt0_amd64_windows。

// attributes: thunk
void __golang rt0_amd64_windows(char a1)
{
  rt0_amd64();
}

然后调用rt0_amd64()

`rt0_amd64`

__int64 __usercall rt0_amd64@<rax>()
{
  return runtime_rt0_go();
}

`rt0_go`

然后调用rt0_go()。这是一个核心函数。

__int64 __usercall runtime_rt0_go@<rax>()
{
  __int64 v0; // rdi
  __int64 v1; // rsi
  __int64 v12; // rax
  char v14[65432]; // [rsp+0h] [rbp-FFC0h] BYREF
  int v15; // [rsp+FF98h] [rbp-28h] BYREF
  __int64 v16; // [rsp+FFA8h] [rbp-18h]
  __int64 v17; // [rsp+FFB0h] [rbp-10h]

  v16 = v0;
  v17 = v1;
  runtime_g0[2] = v14;
  runtime_g0[3] = v14;
  runtime_g0[0] = v14;
  runtime_g0[1] = &v15;
  _RAX = 0LL;
  __asm { cpuid }
  if ( (_DWORD)_RAX )
  {
    if ( (_DWORD)_RBX == 1970169159 && (_DWORD)_RDX == 1231384169 && (_DWORD)_RCX == 1818588270 )
    {
      runtime_isIntel = 1;
      runtime_lfenceBeforeRdtsc = 1;
    }
    _RAX = 1LL;
    __asm { cpuid }
    runtime_processorVersionInfo = _RAX;
  }
  if ( runtime_bss )
  {
    runtime_bss();
    v12 = runtime_g0[0] + 5024LL;
    runtime_g0[2] = runtime_g0[0] + 5024LL;
    runtime_g0[3] = v12;
  }
  runtime_settls();
  *(_QWORD *)NtCurrentTeb()->NtTib.ArbitraryUserPointer = 291LL;
  if ( qword_5685B8 != 291 )
    runtime_abort();
  *(_QWORD *)NtCurrentTeb()->NtTib.ArbitraryUserPointer = runtime_g0;
  runtime_m0[0] = runtime_g0;
  runtime_g0[6] = runtime_m0;
  runtime_check();
  STACK[0x1FF40] = runtime_args(v16, v17);
  runtime_osinit();
  runtime_schedinit();
  STACK[0x1FF28] = runtime_newproc(0, (char)&runtime_mainPC, v15);
  runtime_mstart();
  return runtime_abort();
}

在runtime/asm_amd64.s中有_rt0_amd64()和rt0_go的汇编。

// _rt0_amd64 is common startup code for most amd64 systems when using
// internal linking. This is the entry point for the program from the
// kernel for an ordinary -buildmode=exe program. The stack holds the
// number of arguments and the C-style argv.
TEXT _rt0_amd64(SB),NOSPLIT,$-8
	MOVQ	0(SP), DI	// argc
	LEAQ	8(SP), SI	// argv
	JMP	runtime·rt0_go(SB)

通过RDI和RSI接收到参数个数以及参数所在地址后，跳到runtime.rt0_go函数。

// Defined as ABIInternal since it does not use the stack-based Go ABI (and
// in addition there are no calls to this entry point from Go code).
TEXT runtime·rt0_go<ABIInternal>(SB),NOSPLIT,$0
	// copy arguments forward on an even stack
  // 复制参数数量argc和参数值argv到栈上
	MOVQ	DI, AX		// argc
	MOVQ	SI, BX		// argv
	SUBQ	$(4*8+7), SP		// 2args 2auto，预留4个QWORD，+7字节
	ANDQ	$~15, SP        // 内存对齐
	MOVQ	AX, 16(SP)
	MOVQ	BX, 24(SP)

	// create istack out of the given (operating system) stack.
	// _cgo_init may update stackguard.
  // 初始化 g0 执行栈 
	MOVQ	$runtime·g0(SB), DI
	LEAQ	(-64*1024+104)(SP), BX
	MOVQ	BX, g_stackguard0(DI)
	MOVQ	BX, g_stackguard1(DI)
	MOVQ	BX, (g_stack+stack_lo)(DI)
	MOVQ	SP, (g_stack+stack_hi)(DI)

	// find out information about the processor we're on
  // 使用cpuid获取CPU信息
	MOVL	$0, AX
	CPUID
	MOVL	AX, SI
	CMPL	AX, $0
	JE	nocpuinfo

	// Figure out how to serialize RDTSC.
	// On Intel processors LFENCE is enough. AMD requires MFENCE.
	// Don't know about the rest, so let's do MFENCE.
  // 
	CMPL	BX, $0x756E6547  // "Genu"
	JNE	notintel
	CMPL	DX, $0x49656E69  // "ineI"
	JNE	notintel
	CMPL	CX, $0x6C65746E  // "ntel"
	JNE	notintel
	MOVB	$1, runtime·isIntel(SB)
	MOVB	$1, runtime·lfenceBeforeRdtsc(SB)
notintel:

	// Load EAX=1 cpuid flags
	MOVL	$1, AX
	CPUID
	MOVL	AX, runtime·processorVersionInfo(SB)

nocpuinfo:
	// if there is an _cgo_init, call it.
	MOVQ	_cgo_init(SB), AX
	TESTQ	AX, AX
	JZ	needtls
	// arg 1: g0, already in DI
	MOVQ	$setg_gcc<>(SB), SI // arg 2: setg_gcc
#ifdef GOOS_android
	MOVQ	$runtime·tls_g(SB), DX 	// arg 3: &tls_g
	// arg 4: TLS base, stored in slot 0 (Android's TLS_SLOT_SELF).
	// Compensate for tls_g (+16).
	MOVQ	-16(TLS), CX
#else
	MOVQ	$0, DX	// arg 3, 4: not used when using platform's TLS
	MOVQ	$0, CX
#endif
#ifdef GOOS_windows
	// Adjust for the Win64 calling convention.
	MOVQ	CX, R9 // arg 4
	MOVQ	DX, R8 // arg 3
	MOVQ	SI, DX // arg 2
	MOVQ	DI, CX // arg 1
#endif
	CALL	AX

	// update stackguard after _cgo_init
	MOVQ	$runtime·g0(SB), CX
	MOVQ	(g_stack+stack_lo)(CX), AX
	ADDQ	$const__StackGuard, AX
	MOVQ	AX, g_stackguard0(CX)
	MOVQ	AX, g_stackguard1(CX)

#ifndef GOOS_windows
	JMP ok
#endif
needtls:
#ifdef GOOS_plan9
	// skip TLS setup on Plan 9
	JMP ok
#endif
#ifdef GOOS_solaris
	// skip TLS setup on Solaris
	JMP ok
#endif
#ifdef GOOS_illumos
	// skip TLS setup on illumos
	JMP ok
#endif
#ifdef GOOS_darwin
	// skip TLS setup on Darwin
	JMP ok
#endif
#ifdef GOOS_openbsd
	// skip TLS setup on OpenBSD
	JMP ok
#endif

	LEAQ	runtime·m0+m_tls(SB), DI
	CALL	runtime·settls(SB)

	// store through it, to make sure it works
	get_tls(BX)
	MOVQ	$0x123, g(BX)
	MOVQ	runtime·m0+m_tls(SB), AX
	CMPQ	AX, $0x123
	JEQ 2(PC)
	CALL	runtime·abort(SB)
ok:
	// set the per-goroutine and per-mach "registers"
	get_tls(BX)
	LEAQ	runtime·g0(SB), CX
	MOVQ	CX, g(BX)
	LEAQ	runtime·m0(SB), AX

	// save m->g0 = g0
	MOVQ	CX, m_g0(AX)
	// save m0 to g0->m
	MOVQ	AX, g_m(CX)

	CLD				// convention is D is always left cleared
	CALL	runtime·check(SB)

	MOVL	16(SP), AX		// copy argc
	MOVL	AX, 0(SP)
	MOVQ	24(SP), AX		// copy argv
	MOVQ	AX, 8(SP)
	CALL	runtime·args(SB)
	CALL	runtime·osinit(SB)
	CALL	runtime·schedinit(SB)

	// create a new goroutine to start program
	MOVQ	$runtime·mainPC(SB), AX		// entry
	PUSHQ	AX
	PUSHQ	$0			// arg size
	CALL	runtime·newproc(SB)
	POPQ	AX
	POPQ	AX

	// start this M
	CALL	runtime·mstart(SB)

	CALL	runtime·abort(SB)	// mstart should never return
	RET

	// Prevent dead-code elimination of debugCallV1, which is
	// intended to be called by debuggers.
	MOVQ	$runtime·debugCallV1<ABIInternal>(SB), AX
	RET

// mainPC is a function value for runtime.main, to be passed to newproc.
// The reference to runtime.main is made via ABIInternal, since the
// actual function (not the ABI0 wrapper) is needed by newproc.
DATA	runtime·mainPC+0(SB)/8,$runtime·main<ABIInternal>(SB)
GLOBL	runtime·mainPC(SB),RODATA,$8

首先这个函数原型表明是无参函数。

1	TEXT runtime·rt0_go<ABIInternal>(SB),NOSPLIT,$0

然后在栈上传入argc和argv。

// copy arguments forward on an even stack
MOVQ	DI, AX		// argc
MOVQ	SI, BX		// argv
SUBQ	$(4*8+7), SP		// 2args 2auto
ANDQ	$~15, SP
MOVQ	AX, 16(SP)
MOVQ	BX, 24(SP)

然后初始化g0执行栈。g0是一个特殊的Goroutine。Go语言一个很重要的特性就是协程，通过多个Go协程来充分的运用多核CPU中每一个核心的性能。其中g0是为每个OS线程创建的第一个Goroutine，用于调度其他运行着的线程上的Goroutine。

具体可以看 https://medium.com/a-journey-with-go/go-g0-special-goroutine-8c778c6704d8 来了解。

不过里面作者还需要你去了解Go中M, P, G模型的原理。文章里面附有链接。

然后调用cpuid指令了解当前CPU的信息。

// find out information about the processor we're on
MOVL	$0, AX
CPUID
MOVL	AX, SI
CMPL	AX, $0
JE	nocpuinfo

然后想办法如何将RDTSC序列化。rdtsc指令是返回处理器自开机其的时钟周期的。

// Figure out how to serialize RDTSC.
// On Intel processors LFENCE is enough. AMD requires MFENCE.
// Don't know about the rest, so let's do MFENCE.
CMPL	BX, $0x756E6547  // "Genu"
JNE	notintel
CMPL	DX, $0x49656E69  // "ineI"
JNE	notintel
CMPL	CX, $0x6C65746E  // "ntel"
JNE	notintel
MOVB	$1, runtime·isIntel(SB)
MOVB	$1, runtime·lfenceBeforeRdtsc(SB)

关于“序列化”，首先得知道现代CPU基本上都是乱序执行的，通过将多个指令打乱随机并行执行，这样能提高运行效率。

而序列化的指令，大概的意思就是说其不是乱序执行的，在执行下一条指令之前会拥有CPU和缓存的唯一控制权，而不会和其他指令并行执行。

https://stackoverflow.com/questions/50480511/what-does-serializing-operation-mean-in-the-sfence-documentation

比较考究这个的就是内存屏障这类指令。

下面是非Intel处理器或cpuid指令无效时的应对措施。

notintel:

	// Load EAX=1 cpuid flags
	MOVL	$1, AX
	CPUID
	MOVL	AX, runtime·processorVersionInfo(SB)

nocpuinfo:
	// if there is an _cgo_init, call it.
	MOVQ	_cgo_init(SB), AX
	TESTQ	AX, AX
	JZ	needtls
	// arg 1: g0, already in DI
	MOVQ	$setg_gcc<>(SB), SI // arg 2: setg_gcc

调整调用规范，改为r9, r8, dx, cx寄存器。

#ifdef GOOS_windows
	// Adjust for the Win64 calling convention.
	MOVQ	CX, R9 // arg 4
	MOVQ	DX, R8 // arg 3
	MOVQ	SI, DX // arg 2
	MOVQ	DI, CX // arg 1
#endif

然后调用AX寄存器，来调用runtime.bss()函数（汇编里面是_cgo_init()但是在IDA里面变了）

CALL	AX

设置stackguard

// update stackguard after _cgo_init
MOVQ	$runtime·g0(SB), CX
MOVQ	(g_stack+stack_lo)(CX), AX
ADDQ	$const__StackGuard, AX
MOVQ	AX, g_stackguard0(CX)
MOVQ	AX, g_stackguard1(CX)

设置TLS。

TLS（Thread Local Storage，局部线程存储）是一种变量的存储方法，这个变量在它所在的线程内是全局可访问的，但是不能被其他线程访问到，这样就保持了数据的线程独立性。而熟知的全局变量，是所有线程都可以访问的，这样就不可避免需要锁来控制，增加了控制成本和代码复杂度。

https://zhuanlan.zhihu.com/p/142418922

不同的操作系统，编译器都有自己的实现方法。

https://zh.wikipedia.org/wiki/%E7%BA%BF%E7%A8%8B%E5%B1%80%E9%83%A8%E5%AD%98%E5%82%A8

https://docs.microsoft.com/en-us/cpp/parallel/thread-local-storage-tls?view=msvc-170

LEAQ	runtime·m0+m_tls(SB), DI
CALL	runtime·settls(SB)

// store through it, to make sure it works
get_tls(BX)
MOVQ	$0x123, g(BX)
MOVQ	runtime·m0+m_tls(SB), AX
CMPQ	AX, $0x123
JEQ 2(PC)
CALL	runtime·abort(SB)

为每个goroutine设置寄存器内容

ok:
	// set the per-goroutine and per-mach "registers"
	get_tls(BX)
	LEAQ	runtime·g0(SB), CX
	MOVQ	CX, g(BX)
	LEAQ	runtime·m0(SB), AX

	// save m->g0 = g0
	MOVQ	CX, m_g0(AX)
	// save m0 to g0->m
	MOVQ	AX, g_m(CX)

然后调用runtime.check()

该函数在runtime/runtime1.go/check()，进行各种检查，包括类型的长度Sizeof、结构体字段的偏移量、CAS操作、指针操作、原子操作、汇编指令、栈大小检查等

1 2	CLD // convention is D is always left cleared CALL runtime·check(SB)

然后

MOVL	16(SP), AX		// copy argc
MOVL	AX, 0(SP)
MOVQ	24(SP), AX		// copy argv
MOVQ	AX, 8(SP)
 // 该函数在runtime/runtime1.go/args(c int32, v **byte) 进行命令行参数的初始化
CALL	runtime·args(SB)
 // 该函数在runtime/os_linux.go/osinit() 读取操作系统的CPU核数
CALL	runtime·osinit(SB)
 // 该函数在runtime/proc.go/schedinit() 调度器的初始化，涉及内存空间的初始化、命令行参数的初始化、
 // 垃圾收集器参数的初始化、调度器process的设置等
CALL	runtime·schedinit(SB)

然后运行一个新的goroutine开始主程序（从runtime.main开始）的运行。

// create a new goroutine to start program
MOVQ	$runtime·mainPC(SB), AX		// entry
PUSHQ	AX
PUSHQ	$0			// arg size
CALL	runtime·newproc(SB)
POPQ	AX
POPQ	AX

其中，newproc压入的第一个参数是命令行参数大小，第二个是mainPC指针，指向了runtime.main函数。

// start this M
// runtime/proc.go/mstart() 开始调度，从队列面取G进执行，并执行runtime.main函数
// 在runtime.main的执行中，会依次执行runtime中init数、启动GC收集器、执行用户包的init函数、执行用户的main函数
CALL	runtime·mstart(SB)

CALL	runtime·abort(SB)	// mstart should neverreturn
RET

总结一下：

复制参数到栈上
初始化g0执行栈
使用cpuid指令获取CPU信息
序列化RDTSC指令
设置TLS局部线程存储
为每个goroutine初始化寄存器内容
调用runtime.check()检查各种信息
调用args()初始化命令行参数
调用osinit()读取CPU核数
调用schedinit()调度器初始化
创建新的goroutine，启动主程序

[go runtime] - go程序启动过程 - 掘金 (juejin.cn)

后面还详细讲了一下args，osinit等函数的过程。这里不再详细分析，关注于最后的runtime·newproc(SB)函数

`newproc`

// 创建一个运行`fn`函数的goroutine，且带有siz字节大小的参数
// Create a new g running fn with siz bytes of arguments.
// Put it on the queue of g's waiting to run.
// The compiler turns a go statement into a call to this.
//
// The stack layout of this call is unusual: it assumes that the
// arguments to pass to fn are on the stack sequentially immediately
// after &fn. Hence, they are logically part of newproc's argument
// frame, even though they don't appear in its signature (and can't
// because their types differ between call sites).
//
// This must be nosplit because this stack layout means there are
// untyped arguments in newproc's argument frame. Stack copies won't
// be able to adjust them and stack splits won't be able to copy them.
//
//go:nosplit
func newproc(siz int32, fn *funcval) {
	argp := add(unsafe.Pointer(&fn), sys.PtrSize)
	gp := getg()
	pc := getcallerpc()
	systemstack(func() {
		newg := newproc1(fn, argp, siz, gp, pc)

		_p_ := getg().m.p.ptr()
		runqput(_p_, newg, true)

		if mainStarted {
			wakep()
		}
	})
}

anyway，创建好这个之后，runtime.main()所代表的goroutine就被放在队列中，等待mstart依次执行了。

`mstart`

// mstart is the entry-point for new Ms.
//
// This must not split the stack because we may not even have stack
// bounds set up yet.
//
// May run during STW (because it doesn't have a P yet), so write
// barriers are not allowed.
//
//go:nosplit
//go:nowritebarrierrec
func mstart() {
	_g_ := getg()
    
    /* ... */
	mstart1()

	// Exit this thread.
    /* ... */
	mexit(osStack)
}

func mstart1() {
	_g_ := getg()
	/* ... */
	// Record the caller for use as the top of stack in mcall and
	// for terminating the thread.
	// We're never coming back to mstart1 after we call schedule,
	// so other calls can reuse the current frame.
	save(getcallerpc(), getcallersp())
	asminit()
	minit()

	// Install signal handlers; after minit so that minit can
	// prepare the thread to be able to handle the signals.
	if _g_.m == &m0 {
		mstartm0()
	}

	if fn := _g_.m.mstartfn; fn != nil {
		fn()
	}

	/* ... */
	schedule()
}

可以看到这里依次执行了一大堆函数，包括fn()函数。

然后到了runtime.main函数了。这个函数内直接调用到了main.main主函数。不过由于是call rbx这类非直接调用，所以在strip后的程序中会出现一个奇异的函数指针调用，那个就是main.main函数的位置。具体的定位方式在技巧中会讲。

技巧

快速定位main函数

这是一开始用IDA7.5导致没法完美恢复函数表，被逼无奈学出来的技巧。

当然并不是说恢复符号表就是万能的，因为有题目会混淆函数字符串，使得你恢复后的反而更难以分析。

例子

先写个例子

// hello.go
package main

import "fmt"

func main() {
	fmt.Println("Hello Go")
}

使用

1	go build hello.go

编译

得到hello.exe。

这种情况下是含有符号表信息的。任意版本的IDA皆可直接直接定位到main_main函数。

下面剥去符号表。

1	strip .\hello.exe -o hello_stripped.exe

然后用IDA7.5以下版本打开hello_stripped.exe。

此时就会发现开局就是一大串无效数据，没法定位。

尝试性的定位start函数，但是实际上这个函数与Go的main_main函数毫无干系。

比对有符号表和无符号表的程序，可以发现无符号表的start函数其实是

void __golang rt0_amd64_windows(char a1)
{
  rt0_amd64(a1);
}

且可以发现此函数和main_main函数并没有任何调用关系。（肯定有关系但是对于初学者来说，不是很清晰）

正确方法

main_main先会被runtime_main函数调用

void runtime_main()
{
  PVOID ArbitraryUserPointer; // rax
  __int64 v1; // rdx
  __int64 i; // rax
  __int64 v3; // [rsp+0h] [rbp-50h]
  __int64 v4; // [rsp+0h] [rbp-50h]
  __int64 v5; // [rsp+0h] [rbp-50h]
  __int64 v6; // [rsp+10h] [rbp-40h]
  __int64 v7; // [rsp+20h] [rbp-30h] BYREF
  __int64 v8; // [rsp+28h] [rbp-28h]
  __int64 v9; // [rsp+30h] [rbp-20h]
  __int128 v10; // [rsp+38h] [rbp-18h]
  void *retaddr; // [rsp+50h] [rbp+0h] BYREF

  while ( (unsigned __int64)&retaddr <= *(_QWORD *)(*(_QWORD *)NtCurrentTeb()->NtTib.ArbitraryUserPointer + 16LL) )
    runtime_morestack_noctxt();
  v10 = 0LL;
  HIBYTE(v7) = 0;
  v9 = *(_QWORD *)NtCurrentTeb()->NtTib.ArbitraryUserPointer;
  *(_QWORD *)(**(_QWORD **)(v9 + 48) + 304LL) = 0LL;
  runtime_maxstacksize = 1000000000LL;
  runtime_maxstackceiling = 2000000000LL;
  runtime_mainStarted = 1;
  _InterlockedExchange((volatile __int32 *)&unk_5683A0, 1);
  runtime_systemstack((__int64)&off_4D6058);
  ArbitraryUserPointer = NtCurrentTeb()->NtTib.ArbitraryUserPointer;
  ++*(_DWORD *)(*(_QWORD *)(*(_QWORD *)ArbitraryUserPointer + 48LL) + 580LL);
  v1 = *(_QWORD *)NtCurrentTeb()->NtTib.ArbitraryUserPointer;
  *(_QWORD *)(*(_QWORD *)(v1 + 48) + 312LL) = v1;
  *(_QWORD *)(v1 + 216) = *(_QWORD *)(v1 + 48);
  if ( *(_QWORD **)(v9 + 48) != runtime_m0 )
    goto LABEL_28;
  byte_568678 = 1;
  runtime_nanotime1(v3);
  runtime_runtimeInitTime = v4;
  if ( !v4 )
  {
LABEL_27:
    runtime_throw((__int64)"nanotime returning zero", 23LL);
LABEL_28:
    runtime_throw((__int64)"runtime.main not on m0", 22LL);
    runtime_deferreturn(v5);
    return;
  }
  if ( dword_5AB048 )
  {
    qword_5AAE88 = *(_QWORD *)(*(_QWORD *)NtCurrentTeb()->NtTib.ArbitraryUserPointer + 152LL);
    runtime_inittrace = 1;
  }
  runtime_doInit((__int64)&runtime__inittask);
  HIWORD(v7) = 257;
  *((_QWORD *)&v10 + 1) = &off_4D6060;
  *(_QWORD *)&v10 = (char *)&v7 + 6;
  runtime_gcenable();
  v6 = runtime_makechan((__int64)&unk_4B2580, 0LL);
  if ( runtime_writeBarrier )
    runtime_gcWriteBarrier();
  else
    runtime_main_init_done = v6;
  if ( !runtime_iscgo )
    goto LABEL_12;
  if ( !cgo_thread_start )
  {
LABEL_26:
    runtime_throw((__int64)"_cgo_thread_start missing", 25LL);
    goto LABEL_27;
  }
  if ( !cgo_notify_runtime_init_done )
  {
    runtime_throw((__int64)"_cgo_notify_runtime_init_done missing", 37LL);
    goto LABEL_26;
  }
  runtime_startTemplateThread();
  runtime_cgocall(cgo_notify_runtime_init_done, 0LL, v6);
LABEL_12:
  runtime_doInit((__int64)&main__inittask);
  runtime_inittrace = 0;
  runtime_closechan(runtime_main_init_done);
  BYTE6(v7) = 0;
  runtime_unlockOSThread();
  if ( !runtime_isarchive && !runtime_islibrary )
  {
    main_main();	// 在这里
    if ( runtime_runningPanicDefers )
    {
      for ( i = 0LL; i < 1000 && runtime_runningPanicDefers; i = v8 + 1 )
      {
        v8 = i;
        runtime_mcall((__int64)off_4D6030);
      }
    }
    if ( runtime_panicking )
      v7 = runtime_gopark(0LL, 0LL, 4104, 1LL);
    runtime_exit(0);
    while ( 1 )
      MEMORY[0] = 0;
  }
  HIBYTE(v7) = 0;
  runtime_main_func2(v10);
}

可以发现下面有一串

1 2	while(1) MEMORY[0] = 0;

的错误代码（IDA中会显著标红）

这一块已经在runtime_exit(0)的后面了，一般是不会触发的。否则就会到这里触发异常处理。

看此处汇编

1 2	xor eax, eax mov dword ptr [rax], 0

字节码是

1 2	31 C0 C7 00 00 00 00 00

根据搜寻，整个Go程序中只有这里会有这样的逻辑。所以想要定位main函数，只需要搜索这几个字节码即可。

然后找到所在地址，发现大概率还处于一个被IDA误认为是数据块的地方。

然后转成代码，设置为函数，这样runtime_main就被定位了。

反编译得到伪代码，检查最后一小块

  sub_4057A0();
  v7 = 0;
  sub_441F00();
  if ( !byte_5AABEB && !byte_5AABED )
  {
    ((void (__fastcall *)(__int64, void **))&qword_4A7728[87])(v2, &off_4D6068);
    if ( dword_5AAC54 )
    {
      for ( i = 0i64; i < 1000 && dword_5AAC54; i = v9 + 1 )
      {
        v9 = i;
        sub_463FA0();
      }
    }
    if ( dword_5AAC4C )
      sub_438B20();
    sub_4318E0();
    while ( 1 )
      MEMORY[0] = 0;
  }
  v8 = 0;
  return sub_45F4A0();
}

其中

1	((void (__fastcall )(__int64, void *))&qword_4A7728[87])(v2, &off_4D6068);

就是对main_main函数的调用。

看汇编

1
2
3

.text:00000000004387E6                 mov     rax, cs:off_4D6068
.text:00000000004387ED                 lea     rdx, off_4D6068
.text:00000000004387F4                 call    rax

所以off_4D6068就是main_main函数入口点。

本文作者： Taardis
本文链接： https://taardisaa.github.io/2022/02/17/Go Reverse 1/
版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！